{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Implementation of Boundary Equilibrium GANs\n",
    "Reference: https://arxiv.org/pdf/1703.10717"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Introduction\n",
    "In this task, we can use BEGAN to generate human face.    \n",
    "The dataset is a subset of CelebA.    \n",
    "1, we need to finetune the net G and D.    \n",
    "2, we can test how the net G generate fake faces."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torchvision\n",
    "import torch.nn as nn\n",
    "from torch.utils.data import DataLoader\n",
    "from torch.utils.data.dataset import Dataset\n",
    "from torchvision import datasets\n",
    "from torchvision import transforms\n",
    "from torchvision.utils import save_image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import datetime\n",
    "import os, sys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import glob"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from PIL import Image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.pyplot import imshow, imsave\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "MODEL_NAME = 'BEGAN'\n",
    "DEVICE = torch.device(\"cpu\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "IMAGE_DIM = (32, 32, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def tensor2img(tensor):\n",
    "    img = (np.transpose(tensor.detach().cpu().numpy(), [1,2,0])+1)/2.\n",
    "    return img"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_sample_image(G, n_noise=100, n_samples=64):\n",
    "    \"\"\"\n",
    "        save sample 100 images\n",
    "    \"\"\"\n",
    "    n_rows = int(np.sqrt(n_samples))\n",
    "    z = (torch.rand(size=[n_samples, n_noise])*2-1).to(DEVICE) # U[-1, 1]\n",
    "    x_fake = G(z)\n",
    "    x_fake = torch.cat([torch.cat([x_fake[n_rows*j+i] for i in range(n_rows)], dim=1) for j in range(n_rows)], dim=2)\n",
    "    result = tensor2img(x_fake)\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Encoder(nn.Module):\n",
    "    \"\"\"\n",
    "        Convolutional Encoder\n",
    "    \"\"\"\n",
    "    def __init__(self, in_channel=1, n_filters=128, hidden_dim=100):\n",
    "        super(Encoder, self).__init__()\n",
    "        assert IMAGE_DIM[0] % 2**2 == 0, 'Should be divided 4'\n",
    "        self.flatten_dim = IMAGE_DIM[0]//2**2\n",
    "        self.conv = nn.Sequential(\n",
    "            # conv0\n",
    "            nn.Conv2d(in_channel, n_filters, 3, stride=1, padding=1, bias=False),\n",
    "            nn.BatchNorm2d(n_filters),\n",
    "            nn.LeakyReLU(0.2),\n",
    "            # conv1\n",
    "            nn.Conv2d(n_filters, n_filters, 3, stride=1, padding=1, bias=False),\n",
    "            nn.BatchNorm2d(n_filters),\n",
    "            nn.LeakyReLU(0.2),\n",
    "            # conv2\n",
    "            nn.Conv2d(n_filters, n_filters*2, 3, stride=2, padding=1, bias=False),\n",
    "            nn.BatchNorm2d(n_filters*2),\n",
    "            nn.LeakyReLU(0.2),\n",
    "            # conv3\n",
    "            nn.Conv2d(n_filters*2, n_filters*2, 3, stride=1, padding=1, bias=False),\n",
    "            nn.BatchNorm2d(n_filters*2),\n",
    "            nn.LeakyReLU(0.2),\n",
    "            # conv4\n",
    "            nn.Conv2d(n_filters*2, n_filters*3, 3, stride=2, padding=1, bias=False),\n",
    "            nn.BatchNorm2d(n_filters*3),\n",
    "            nn.LeakyReLU(0.2),\n",
    "            # conv5\n",
    "            nn.Conv2d(n_filters*3, n_filters*3, 3, stride=1, padding=1, bias=False),\n",
    "            nn.BatchNorm2d(n_filters*3),\n",
    "            nn.LeakyReLU(0.2),\n",
    "            # conv6\n",
    "            nn.Conv2d(n_filters*3, n_filters*3, 3, stride=1, padding=1, bias=False),\n",
    "            nn.BatchNorm2d(n_filters*3),\n",
    "            nn.LeakyReLU(0.2),\n",
    "        )\n",
    "        self.fc = nn.Linear(self.flatten_dim**2*n_filters*3, hidden_dim)\n",
    "    \n",
    "    def forward(self, x):\n",
    "        h = self.conv(x)\n",
    "        h = h.view(h.size(0), -1)\n",
    "        h = self.fc(h)\n",
    "        return h"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Decoder(nn.Module):\n",
    "    \"\"\"\n",
    "        Convolutional Decoder\n",
    "    \"\"\"\n",
    "    def __init__(self, out_channel=1, n_filters=128, n_noise=100):\n",
    "        super(Decoder, self).__init__()\n",
    "        assert IMAGE_DIM[0] % 2**2 == 0, 'Should be divided 4'\n",
    "        self.flatten_dim = IMAGE_DIM[0]//2**2\n",
    "        self.fc = nn.Sequential(\n",
    "            nn.Linear(n_noise, self.flatten_dim**2*n_filters),\n",
    "        )\n",
    "        self.conv = nn.Sequential(\n",
    "            # conv1\n",
    "            nn.Conv2d(n_filters, n_filters, 3, stride=1, padding=1, bias=False),\n",
    "            nn.BatchNorm2d(n_filters),\n",
    "            nn.LeakyReLU(0.2),\n",
    "            # conv2\n",
    "            nn.Conv2d(n_filters, n_filters, 3, stride=1, padding=1, bias=False),\n",
    "            nn.BatchNorm2d(n_filters),\n",
    "            nn.LeakyReLU(0.2),\n",
    "            nn.Upsample(scale_factor=2, mode='nearest'),\n",
    "            # conv3\n",
    "            nn.Conv2d(n_filters, n_filters, 3, stride=1, padding=1, bias=False),\n",
    "            nn.BatchNorm2d(n_filters),\n",
    "            nn.LeakyReLU(0.2),\n",
    "            # conv4\n",
    "            nn.Conv2d(n_filters, n_filters, 3, stride=1, padding=1, bias=False),\n",
    "            nn.BatchNorm2d(n_filters),\n",
    "            nn.LeakyReLU(0.2),\n",
    "            nn.Upsample(scale_factor=2, mode='nearest'),\n",
    "            # conv5\n",
    "            nn.Conv2d(n_filters, n_filters, 3, stride=1, padding=1, bias=False),\n",
    "            nn.BatchNorm2d(n_filters),\n",
    "            nn.LeakyReLU(0.2),\n",
    "            # conv6\n",
    "            nn.Conv2d(n_filters, n_filters, 3, stride=1, padding=1, bias=False),\n",
    "            nn.BatchNorm2d(n_filters),\n",
    "            nn.LeakyReLU(0.2),\n",
    "            # conv6\n",
    "            nn.Conv2d(n_filters, out_channel, 3, stride=1, padding=1, bias=True),\n",
    "            nn.Tanh()\n",
    "        )\n",
    "    \n",
    "    def forward(self, h):\n",
    "        h = self.fc(h)\n",
    "        h = h.view(h.size(0), -1, self.flatten_dim, self.flatten_dim)\n",
    "        x = self.conv(h)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Discriminator(nn.Module):\n",
    "    \"\"\"\n",
    "        Convolutional Discriminator\n",
    "    \"\"\"\n",
    "    def __init__(self, in_channel=1, n_filters=128, hidden_dim=64):\n",
    "        super(Discriminator, self).__init__()\n",
    "        self.encoder = Encoder(in_channel=in_channel, n_filters=n_filters, hidden_dim=hidden_dim)\n",
    "        self.decoder = Decoder(out_channel=in_channel, n_filters=n_filters, n_noise=hidden_dim)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        h = self.encoder(x)\n",
    "        x_ = self.decoder(h)\n",
    "        return x_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Generator(nn.Module):\n",
    "    \"\"\"\n",
    "        Convolutional Generator\n",
    "    \"\"\"\n",
    "    def __init__(self, out_channel=1, n_filters=128, n_noise=64):\n",
    "        super(Generator, self).__init__()\n",
    "        self.decoder = Decoder(out_channel=out_channel, n_filters=n_filters, n_noise=n_noise)\n",
    "        \n",
    "    def forward(self, h):\n",
    "        x_ = self.decoder(h)\n",
    "        return x_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "transform = transforms.Compose([transforms.Resize((IMAGE_DIM[0],IMAGE_DIM[1])),\n",
    "                                transforms.ToTensor(),\n",
    "                                transforms.Normalize(mean=(0.5, 0.5, 0.5),\n",
    "                                std=(0.5, 0.5, 0.5))\n",
    "                               ])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "CelebA-ch subset download: [link](https://drive.google.com/file/d/1RD55pZnakqEZn3FMPaoB2c1ShaouJJ_1/view?usp=sharing)    \n",
    "unzip it and put into current dir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This subset dataset has 402 images\n"
     ]
    }
   ],
   "source": [
    "dataset = datasets.ImageFolder(root='./celeba', transform=transform)\n",
    "print('This subset dataset has {} images'.format(len(dataset)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 32\n",
    "n_noise = 64"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_loader = DataLoader(dataset=dataset, batch_size=batch_size, shuffle=True, drop_last=True, num_workers=1, pin_memory=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## build network G and D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "D = Discriminator(in_channel=IMAGE_DIM[-1], hidden_dim=n_noise).to(DEVICE)\n",
    "G = Generator(out_channel=IMAGE_DIM[-1], n_noise=n_noise).to(DEVICE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load pretrained G and D\n",
    "Train a full network needs GPU and many times. So we can finetune the network on the provided pretrained model. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "download pretrained network: [link](https://drive.google.com/file/d/1p43gmCvWmrBbOJSjIsJtLOBfOJ1yN8ei/view?usp=sharing)    \n",
    "put into current dir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pretrained_path = './began_pretrained.pth.tar'\n",
    "state = torch.load(pretrained_path,map_location=lambda storage, loc: storage)\n",
    "G.load_state_dict(state['G'])\n",
    "D.load_state_dict(state['D'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "lr_G = 0.00002\n",
    "lr_D = 0.00002\n",
    "D_opt = torch.optim.Adam(D.parameters(), lr=lr_G, betas=(0.5, 0.999))\n",
    "G_opt = torch.optim.Adam(G.parameters(), lr=lr_D, betas=(0.5, 0.999))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "# BEGAN causes mode collapse. it can be addressed by decaying lr\n",
    "D_scheduler = torch.optim.lr_scheduler.MultiStepLR(D_opt, milestones=[3, 10, 17], gamma=0.6)\n",
    "G_scheduler = torch.optim.lr_scheduler.MultiStepLR(G_opt, milestones=[3, 10, 17], gamma=0.6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion = nn.L1Loss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "max_epoch = 1\n",
    "lr_k = 0.001\n",
    "gamma = 0.7\n",
    "k_t = 0\n",
    "log_term = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "steps_per_epoch = len(data_loader.dataset) // batch_size\n",
    "steps_per_epoch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not os.path.exists('samples'):\n",
    "    os.makedirs('samples')\n",
    "    \n",
    "if not os.path.exists('ckpt'):\n",
    "    os.makedirs('ckpt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "def save_checkpoint(state, file_name='checkpoint.pth.tar'):\n",
    "    torch.save(state, file_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0/1, Step: 0/12, D Loss: 0.0896, G Loss: 0.0551, k: 0.0000, M: 0.0972, lr: 0.0000200, Time:20:21:02\n",
      "Epoch: 0/1, Step: 1/12, D Loss: 0.0928, G Loss: 0.0488, k: 0.0000, M: 0.1089, lr: 0.0000200, Time:20:21:14\n",
      "Epoch: 0/1, Step: 2/12, D Loss: 0.0903, G Loss: 0.0483, k: 0.0000, M: 0.1053, lr: 0.0000200, Time:20:21:26\n",
      "Epoch: 0/1, Step: 3/12, D Loss: 0.0894, G Loss: 0.0486, k: 0.0001, M: 0.1034, lr: 0.0000200, Time:20:21:39\n",
      "Epoch: 0/1, Step: 4/12, D Loss: 0.0852, G Loss: 0.0484, k: 0.0001, M: 0.0964, lr: 0.0000200, Time:20:21:51\n",
      "Epoch: 0/1, Step: 5/12, D Loss: 0.0901, G Loss: 0.0483, k: 0.0001, M: 0.1048, lr: 0.0000200, Time:20:22:03\n",
      "Epoch: 0/1, Step: 6/12, D Loss: 0.0891, G Loss: 0.0479, k: 0.0001, M: 0.1036, lr: 0.0000200, Time:20:22:16\n",
      "Epoch: 0/1, Step: 7/12, D Loss: 0.0859, G Loss: 0.0468, k: 0.0001, M: 0.0992, lr: 0.0000200, Time:20:22:28\n",
      "Epoch: 0/1, Step: 8/12, D Loss: 0.0920, G Loss: 0.0486, k: 0.0001, M: 0.1078, lr: 0.0000200, Time:20:22:40\n",
      "Epoch: 0/1, Step: 9/12, D Loss: 0.0821, G Loss: 0.0468, k: 0.0001, M: 0.0928, lr: 0.0000200, Time:20:22:52\n",
      "Epoch: 0/1, Step: 10/12, D Loss: 0.0870, G Loss: 0.0479, k: 0.0001, M: 0.1000, lr: 0.0000200, Time:20:23:04\n",
      "Epoch: 0/1, Step: 11/12, D Loss: 0.0878, G Loss: 0.0469, k: 0.0002, M: 0.1024, lr: 0.0000200, Time:20:23:16\n"
     ]
    }
   ],
   "source": [
    "m_lst = []\n",
    "bestM = 1.\n",
    "for epoch in range(max_epoch):\n",
    "    step = 0\n",
    "    \n",
    "    for idx, (images, labels) in enumerate(data_loader):\n",
    "        G.zero_grad()\n",
    "        # Training Discriminator\n",
    "        x = images.to(DEVICE)\n",
    "        x_outputs = D(x)\n",
    "        D_x_loss = criterion(x_outputs, x)\n",
    "\n",
    "        z = (torch.rand(size=[batch_size, n_noise])*2-1).to(DEVICE)\n",
    "        x_fake = G(z)\n",
    "        z_outputs = D(x_fake.detach())\n",
    "        D_z_loss = criterion(z_outputs, x_fake)\n",
    "        \n",
    "        D_loss = D_x_loss - k_t*D_z_loss\n",
    "        \n",
    "        D.zero_grad()\n",
    "        D_loss.backward()\n",
    "        D_opt.step()\n",
    "\n",
    "        # Training Generator\n",
    "        z = (torch.rand(size=[batch_size, n_noise])*2-1).to(DEVICE)\n",
    "        x_fake = G(z)\n",
    "        z_outputs = D(x_fake)\n",
    "        G_loss = criterion(x_fake, z_outputs)\n",
    "\n",
    "        G.zero_grad()\n",
    "        G_loss.backward()\n",
    "        G_opt.step()\n",
    "        \n",
    "        bal = (gamma*D_x_loss - G_loss).detach()\n",
    "        k_t = min(max(k_t + lr_k*bal, 0), 1)\n",
    "        M_global = D_x_loss.detach() + torch.abs(bal)\n",
    "        \n",
    "        \n",
    "        if step % log_term == 0:\n",
    "            m_lst.append(M_global)\n",
    "            dt = datetime.datetime.now().strftime('%H:%M:%S')\n",
    "            print('Epoch: {}/{}, Step: {}/{}, D Loss: {:.4f}, G Loss: {:.4f}, k: {:.4f}, M: {:.4f}, lr: {:.7f}, Time:{}'.format(epoch, max_epoch, step, steps_per_epoch, D_loss.item(), G_loss.item(), k_t, M_global.item(), G_scheduler.get_lr()[0], dt))\n",
    "            G.eval()\n",
    "            img = get_sample_image(G, n_noise, n_samples=25)\n",
    "            imsave('samples/{}_step{:06d}.jpg'.format(MODEL_NAME, step), img)\n",
    "            G.train()\n",
    "        \n",
    "        step += 1\n",
    "    D_scheduler.step()\n",
    "    G_scheduler.step()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "save_checkpoint({'global_step': step,\n",
    "     'D':D.state_dict(),\n",
    "     'G':G.state_dict(),\n",
    "     'd_optim': D_opt.state_dict(),\n",
    "     'g_optim' : G_opt.state_dict()},\n",
    "    'ckpt/began{:06d}.pth.tar'.format(step))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Testing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Load the trained model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "G_path = sorted(glob.glob(os.path.join('ckpt', '*.pth.tar')))[-1]\n",
    "state = torch.load(G_path,map_location=lambda storage, loc: storage)\n",
    "G.load_state_dict(state['G'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "G.eval()\n",
    "None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Input noise to net G, output generated face images."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x136ec4150>"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "img = get_sample_image(G, n_noise, n_samples=25)\n",
    "imshow(img)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x1370001d0>"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Fake Image\n",
    "idx = [2, 3]\n",
    "row, col = IMAGE_DIM[0]*idx[0], IMAGE_DIM[1]*idx[1]\n",
    "imshow(img[row:row+IMAGE_DIM[0], col:col+IMAGE_DIM[1], :])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x13748a410>"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Real Image from dataset\n",
    "i = 15\n",
    "images, labels = dataset[i]\n",
    "rimg = tensor2img(dataset[i][0])\n",
    "imshow(rimg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Input Interpolated noise, output gradual face images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sample_noise(size=None):\n",
    "    z = np.random.random(size=size)*2-1\n",
    "    return z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([10, 64])"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z_a, z_b = sample_noise(n_noise), sample_noise(n_noise)\n",
    "zs = torch.tensor([np.linspace(z_a[i], z_b[i], num=10) for i in range(n_noise)], dtype=torch.float32).to(DEVICE)\n",
    "zs = torch.transpose(zs, 0, 1)\n",
    "zs.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([3, 32, 320])"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imgs = G(zs).detach()\n",
    "imgs = torch.cat([imgs[i] for i in range(10)], dim=-1)\n",
    "imgs.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x137ee2490>"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(20, 3))\n",
    "imshow(tensor2img(imgs))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
